<?php

/**
 * This is the HTML pseudo-parser for the Yadis library.
 *
 * PHP versions 4 and 5
 *
 * LICENSE: See the COPYING file included in this distribution.
 *
 * @package OpenID
 * @author JanRain, Inc. <openid@janrain.com>
 * @copyright 2005-2008 Janrain, Inc.
 * @license http://www.apache.org/licenses/LICENSE-2.0 Apache
 */

// Do not allow direct access
defined( '_JEXEC' ) or die( 'Restricted access' );

/**
 * This class is responsible for scanning an HTML string to find META
 * tags and their attributes.  This is used by the Yadis discovery
 * process.  This class must be instantiated to be used.
 *
 * @package OpenID
 */
class Auth_Yadis_ParseHTML {

	/**
	 * @access private
	 */
	var $_re_flags = "si";

	/**
	 * @access private
	 */
	var $_removed_re =
		   "<!--.*?-->|<!\[CDATA\[.*?\]\]>|<script\b(?!:)[^>]*>.*?<\/script>";

	/**
	 * @access private
	 */
	var $_tag_expr = "<%s%s(?:\s.*?)?%s>";

	/**
	 * @access private
	 */
	var $_attr_find = '\b([-\w]+)=(".*?"|\'.*?\'|.+?)[\/\s>]';

	function Auth_Yadis_ParseHTML()
	{
		$this->_attr_find = sprintf("/%s/%s",
									$this->_attr_find,
									$this->_re_flags);

		$this->_removed_re = sprintf("/%s/%s",
									 $this->_removed_re,
									 $this->_re_flags);

		$this->_entity_replacements = array(
											'amp' => '&',
											'lt' => '<',
											'gt' => '>',
											'quot' => '"'
											);

		$this->_ent_replace =
			sprintf("&(%s);", implode("|",
									  $this->_entity_replacements));
	}

	/**
	 * Replace HTML entities (amp, lt, gt, and quot) as well as
	 * numeric entities (e.g. #x9f;) with their actual values and
	 * return the new string.
	 *
	 * @access private
	 * @param string $str The string in which to look for entities
	 * @return string $new_str The new string entities decoded
	 */
	function replaceEntities($str)
	{
		foreach ($this->_entity_replacements as $old => $new) {
			$str = preg_replace(sprintf("/&%s;/", $old), $new, $str);
		}

		// Replace numeric entities because html_entity_decode doesn't
		// do it for us.
		$str = preg_replace('~&#x([0-9a-f]+);~ei', 'chr(hexdec("\\1"))', $str);
		$str = preg_replace('~&#([0-9]+);~e', 'chr(\\1)', $str);

		return $str;
	}

	/**
	 * Strip single and double quotes off of a string, if they are
	 * present.
	 *
	 * @access private
	 * @param string $str The original string
	 * @return string $new_str The new string with leading and
	 * trailing quotes removed
	 */
	function removeQuotes($str)
	{
		$matches = array();
		$double = '/^"(.*)"$/';
		$single = "/^\'(.*)\'$/";

		if (preg_match($double, $str, $matches)) {
			return $matches[1];
		} else if (preg_match($single, $str, $matches)) {
			return $matches[1];
		} else {
			return $str;
		}
	}

	/**
	 * Create a regular expression that will match an opening 
	 * or closing tag from a set of names.
	 *
	 * @access private
	 * @param mixed $tag_names Tag names to match
	 * @param mixed $close false/0 = no, true/1 = yes, other = maybe
	 * @param mixed $self_close false/0 = no, true/1 = yes, other = maybe
	 * @return string $regex A regular expression string to be used
	 * in, say, preg_match.
	 */
	function tagPattern($tag_names, $close, $self_close)
	{
		if (is_array($tag_names)) {
			$tag_names = '(?:'.implode('|',$tag_names).')';
		}
		if ($close) {
			$close = '\/' . (($close == 1)? '' : '?');
		} else {
			$close = '';
		}
		if ($self_close) {
			$self_close = '(?:\/\s*)' . (($self_close == 1)? '' : '?');
		} else {
			$self_close = '';
		}
		$expr = sprintf($this->_tag_expr, $close, $tag_names, $self_close);

		return sprintf("/%s/%s", $expr, $this->_re_flags);
	}

	/**
	 * Given an HTML document string, this finds all the META tags in
	 * the document, provided they are found in the
	 * <HTML><HEAD>...</HEAD> section of the document.  The <HTML> tag
	 * may be missing.
	 *
	 * @access private
	 * @param string $html_string An HTMl document string
	 * @return array $tag_list Array of tags; each tag is an array of
	 * attribute -> value.
	 */
	function getMetaTags($html_string)
	{
		$html_string = preg_replace($this->_removed_re,
									"",
									$html_string);

		$key_tags = array($this->tagPattern('html', false, false),
						  $this->tagPattern('head', false, false),
						  $this->tagPattern('head', true, false),
						  $this->tagPattern('html', true, false),
						  $this->tagPattern(array(
						  'body', 'frameset', 'frame', 'p', 'div',
						  'table','span','a'), 'maybe', 'maybe'));
		$key_tags_pos = array();
		foreach ($key_tags as $pat) {
			$matches = array();
			preg_match($pat, $html_string, $matches, PREG_OFFSET_CAPTURE);
			if($matches) {
				$key_tags_pos[] = $matches[0][1];
			} else {
				$key_tags_pos[] = null;
			}
		}
		// no opening head tag
		if (is_null($key_tags_pos[1])) {
			return array();
		}
		// the effective </head> is the min of the following
		if (is_null($key_tags_pos[2])) {
			$key_tags_pos[2] = strlen($html_string);
		}
		foreach (array($key_tags_pos[3], $key_tags_pos[4]) as $pos) {
			if (!is_null($pos) && $pos < $key_tags_pos[2]) {
				$key_tags_pos[2] = $pos;
			}
		}
		// closing head tag comes before opening head tag
		if ($key_tags_pos[1] > $key_tags_pos[2]) {
			return array();
		}
		// if there is an opening html tag, make sure the opening head tag
		// comes after it
		if (!is_null($key_tags_pos[0]) && $key_tags_pos[1] < $key_tags_pos[0]) {
			return array();
		}
		$html_string = substr($html_string, $key_tags_pos[1],
							  ($key_tags_pos[2]-$key_tags_pos[1]));

		$link_data = array();
		$link_matches = array();
		
		if (!preg_match_all($this->tagPattern('meta', false, 'maybe'),
							$html_string, $link_matches)) {
			return array();
		}

		foreach ($link_matches[0] as $link) {
			$attr_matches = array();
			preg_match_all($this->_attr_find, $link, $attr_matches);
			$link_attrs = array();
			foreach ($attr_matches[0] as $index => $full_match) {
				$name = $attr_matches[1][$index];
				$value = $this->replaceEntities(
							  $this->removeQuotes($attr_matches[2][$index]));

				$link_attrs[strtolower($name)] = $value;
			}
			$link_data[] = $link_attrs;
		}

		return $link_data;
	}

	/**
	 * Looks for a META tag with an "http-equiv" attribute whose value
	 * is one of ("x-xrds-location", "x-yadis-location"), ignoring
	 * case.  If such a META tag is found, its "content" attribute
	 * value is returned.
	 *
	 * @param string $html_string An HTML document in string format
	 * @return mixed $content The "content" attribute value of the
	 * META tag, if found, or null if no such tag was found.
	 */
	function getHTTPEquiv($html_string)
	{
		$meta_tags = $this->getMetaTags($html_string);

		if ($meta_tags) {
			foreach ($meta_tags as $tag) {
				if (array_key_exists('http-equiv', $tag) &&
					(in_array(strtolower($tag['http-equiv']),
							  array('x-xrds-location', 'x-yadis-location'))) &&
					array_key_exists('content', $tag)) {
					return $tag['content'];
				}
			}
		}

		return null;
	}
}

?>